import z from "zod";
import { baseProcedure, createTRPCRouter } from "../trpc/init";
import fs from "fs";
import path from "path";
import os from "os";
import { exec } from "child_process";

// 定义文件信息类型
const FileInfoSchema = z.object({
  name: z.string(),
  isDirectory: z.boolean(),
  size: z.number().optional(),
  modified: z.date().optional(),
  ext: z.string().optional(), // 文件扩展名
});

type FileInfo = z.output<typeof FileInfoSchema>;

export const fileManagerRouter = createTRPCRouter({
  // 获取系统驱动器列表
  getDrives: baseProcedure
    .input(z.void())
    .query(() => {
      // Windows系统获取驱动器
      if (os.platform() === 'win32') {
        // 在Windows上，我们可以通过遍历字母A-Z来查找存在的驱动器
        const drives: string[] = [];
        for (let i = 65; i <= 90; i++) {
          const drive = String.fromCharCode(i) + ':\\';
          try {
            // 检查驱动器是否存在
            fs.accessSync(drive, fs.constants.F_OK);
            drives.push(drive);
          } catch {
            // 驱动器不存在，跳过
            continue;
          }
        }
        return drives;
      } else {
        // 非Windows系统默认返回根目录
        return ['/'];
      }
    }),

  // 获取目录内容
  getDirectoryContents: baseProcedure
    .input(z.object({
      path: z.string()
    }))
    .query(({ input }) => {
      const { path: dirPath } = input;
      
      // 检查路径是否存在
      if (!fs.existsSync(dirPath)) {
        throw new Error(`路径不存在: ${dirPath}`);
      }
      
      // 检查是否为目录
      const stat = fs.statSync(dirPath);
      if (!stat.isDirectory()) {
        throw new Error(`路径不是目录: ${dirPath}`);
      }
      
      // 读取目录内容
      const items = fs.readdirSync(dirPath);
      const contents: FileInfo[] = [];
      
      for (const item of items) {
        try {
          const fullPath = path.join(dirPath, item);
          const itemStat = fs.statSync(fullPath);
          
          contents.push({
            name: item,
            isDirectory: itemStat.isDirectory(),
            size: itemStat.size,
            modified: itemStat.mtime,
            ext: itemStat.isFile() ? path.extname(item) : undefined
          });
        } catch (error) {
          // 如果无法获取文件信息，跳过该项
          console.warn(`无法读取文件信息: ${item}`, error);
        }
      }
      
      return contents;
    }),

  // 打开文件（通过系统默认程序）
  openFile: baseProcedure
    .input(z.object({
      path: z.string()
    }))
    .mutation(({ input }) => {
      let { path: filePath } = input;
      
      // 在Windows系统上，确保使用反斜杠作为路径分隔符
      if (os.platform() === 'win32') {
        filePath = filePath.replace(/\//g, '\\');
      }
      
      // 检查文件是否存在
      if (!fs.existsSync(filePath)) {
        throw new Error(`文件不存在: ${filePath}`);
      }
      
      // 检查是否为文件
      const stat = fs.statSync(filePath);
      if (!stat.isFile()) {
        throw new Error(`指定路径不是文件: ${filePath}`);
      }
      
      // 在不同平台上使用不同的命令打开文件
      let command: string;
      switch (os.platform()) {
      case 'win32':
        // 在Windows上，需要特殊处理路径中的空格和特殊字符
        command = `start "" "${filePath.replace(/"/g, '""')}"`;
        break;
      case 'darwin': // macOS
        command = `open "${filePath}"`;
        break;
      default: // Linux
        command = `xdg-open "${filePath}"`;
      }
      
      // 执行命令打开文件
      exec(command, (error) => {
        if (error) {
          throw new Error(`无法打开文件: ${error.message}`);
        }
      });
      
      return { success: true };
    })
});